home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / lib / rcscripts / sh / rc-services.sh < prev   
Encoding:
Text File  |  2006-04-25  |  16.2 KB  |  845 lines
  1. # Copyright 1999-2004 Gentoo Foundation
  2. # Distributed under the terms of the GNU General Public License v2
  3. # $Header$
  4.  
  5. # RC Dependency and misc service functions
  6.  
  7. RC_GOT_SERVICES="yes"
  8.  
  9. [ "${RC_GOT_FUNCTIONS}" != "yes" ] && source /sbin/functions.sh
  10.  
  11. if [ "${RC_GOT_DEPTREE_INFO}" != "yes" ]
  12. then
  13.     if ! /sbin/depscan.sh
  14.     then
  15.         echo
  16.         eerror "Error running '/sbin/depscan.sh'!"
  17.         eerror "Please correct any problems above."
  18.  
  19.         exit 1
  20.     fi
  21.  
  22.     source "${svcdir}/deptree"
  23.  
  24.     if [ "${RC_GOT_DEPTREE_INFO}" != "yes" ]
  25.     then
  26.         echo
  27.         eerror "Dependency info is missing!  Please run"
  28.         echo
  29.         eerror "  # /sbin/depscan.sh"
  30.         echo
  31.         eerror "to fix this."
  32.  
  33.         exit 1
  34.     fi
  35. fi
  36.  
  37.  
  38. #####################
  39. # Internal variables
  40. #####################
  41.  
  42. # The name of the service whose dependency info we currently have
  43. rc_name=
  44. # The index of the service whose dependency info we currently have
  45. rc_index=0
  46. # Our dependency types ...
  47. rc_ineed=
  48. rc_needsme=
  49. rc_iuse=
  50. rc_usesme=
  51. rc_ibefore=
  52. rc_iafter=
  53. rc_broken=
  54. rc_parallel=
  55. rc_mtime=
  56.  
  57. ############
  58. # Functions
  59. ############
  60.  
  61. # boot check_mtime(service, mtime)
  62. #
  63. #   Return 0 if 'service's mtime is the same as 'mtime'
  64. #
  65. check_mtime() {
  66.     # This one have no 'mtime' ...
  67.     [ "$1" = "net" ] && return 0
  68.  
  69.     [ -z "$1" -o -z "$2" ] && return 1
  70.  
  71.     # Do not fail if there is no script, as virtuals
  72.     # will then not work ...
  73.     if [ -e "/etc/init.d/$1" -a -x "/bin/stat" ] && \
  74.        [ "$(stat -c "%Y" "/etc/init.d/$1" 2>/dev/null)" -ne "$2" ]
  75.     then
  76.         return 1
  77.     fi
  78.  
  79.     return 0
  80. }
  81.  
  82. # bool get_service_index(service, index)
  83. #
  84. #   Print the index of 'service'.  'index' is the current index.
  85. #
  86. get_service_index() {
  87.     local x=1
  88.     local index="$2"
  89.     local myservice="$1"
  90.  
  91.     if [ -z "$1" -o -z "$2" ]
  92.     then
  93.         echo "0"
  94.         return 1
  95.     fi
  96.  
  97.     # Do we already have the index?
  98.     if [ -n "${index}" ] && [ "${index}" -gt 0 -a \
  99.          "${myservice}" = "${RC_DEPEND_TREE[${index}]}" ]
  100.     then
  101.         echo "${index}"
  102.         return 0
  103.     fi
  104.  
  105.     while [ "${x}" -le "${RC_DEPEND_TREE[0]}" ]
  106.     do
  107.         index=$((${x} * ${rc_index_scale}))
  108.         
  109.         if [ "${myservice}" = "${RC_DEPEND_TREE[${index}]}" ]
  110.         then
  111.             echo "${index}"
  112.             return 0
  113.         fi
  114.  
  115.         let "x += 1"
  116.     done
  117.  
  118.     echo "0"
  119.     return 1
  120. }
  121.  
  122. # bool get_dep_info(service)
  123. #
  124. #   Set the Dependency variables to contain data for 'service'
  125. #
  126. get_dep_info() {
  127.     local myservice="$1"
  128.  
  129.     [ -z "$1" ] && return 1
  130.  
  131.     # We already have the right stuff ...
  132.     if [ "${myservice}" = "${rc_name}" -a -n "${rc_mtime}" ] && \
  133.          check_mtime "${myservice}" "${rc_mtime}"
  134.     then
  135.        return 0
  136.     fi
  137.  
  138.     rc_index="`get_service_index "${myservice}" "${rc_index}"`"
  139.     rc_mtime="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_mtime}))]}"
  140.  
  141.     # Does the stored mtime match that of the current rc-script?
  142.     if ! check_mtime "${myservice}" "${rc_mtime}"
  143.     then
  144.         # Nope, check if we already ran depscan.sh
  145.         source "${svcdir}/deptree"
  146.         rc_index="`get_service_index "${myservice}" "${rc_index}"`"
  147.         rc_mtime="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_mtime}))]}"
  148.  
  149.         # Do we have it now?
  150.         if ! check_mtime "${myservice}" "${rc_mtime}"
  151.         then
  152.             # Not?  So run depscan.sh ...
  153.             einfo "Re-caching dependency info (mtimes differ)..." &>/dev/stderr
  154.             if ! /sbin/depscan.sh &>/dev/null
  155.             then
  156.                 return 1
  157.             else
  158.                 # We want to check if we got the dep info later on ...
  159.                 unset RC_GOT_DEPTREE_INFO
  160.                 source "${svcdir}/deptree"
  161.                 # Everything "OK" ?
  162.                 [ "${RC_GOT_DEPTREE_INFO}" != "yes" ] && return 1
  163.             fi
  164.  
  165.             rc_index="`get_service_index "${myservice}" "${rc_index}"`"
  166.         fi
  167.     fi
  168.     
  169.     # Verify that we have the correct index (rc_index) ...
  170.     [ "${rc_index}" -eq 0 ] && return 1
  171.         
  172.     rc_name="${RC_DEPEND_TREE[${rc_index}]}"
  173.     rc_ineed="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_ineed}))]}"
  174.     rc_needsme="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_needsme}))]}"
  175.     rc_iuse="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_iuse}))]}"
  176.     rc_usesme="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_usesme}))]}"
  177.     rc_ibefore="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_ibefore}))]}"
  178.     rc_iafter="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_iafter}))]}"
  179.     rc_broken="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_broken}))]}"
  180.     rc_parallel="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_parallel}))]}"
  181.     rc_mtime="${RC_DEPEND_TREE[$((${rc_index} + ${rc_type_mtime}))]}"
  182.         
  183.     return 0
  184. }
  185.  
  186. # string check_dependency(deptype, service1)
  187. #
  188. #   List all the services that depend on 'service1' of dependency
  189. #   type 'deptype'
  190. #
  191. # bool check_dependency(deptype, -t, service1, service2)
  192. #
  193. #   Returns true if 'service2' is a dependency of type 'deptype'
  194. #   of 'service1'
  195. #
  196. check_dependency() {
  197.     local x=
  198.     local myservice=
  199.  
  200.     [ -z "$1" -o -z "$2" ] && return 1
  201.     
  202.     # Set the dependency variables to relate to 'service1'
  203.     if [ "$2" = "-t" ]
  204.     then
  205.         [ -z "$3" -o -z "$4" ] && return 1
  206.  
  207.         myservice="$3"
  208.     else
  209.         myservice="$2"
  210.     fi
  211.  
  212.     get_dep_info "${myservice}" >/dev/null || {
  213.         eerror "Could not get dependency info for \"${myservice}\"!" > /dev/stderr
  214.         eerror "Please run:" > /dev/stderr
  215.         echo > /dev/stderr
  216.         eerror "  # /sbin/depscan.sh" > /dev/stderr
  217.         echo > /dev/stderr
  218.         eerror "to try and fix this." > /dev/stderr
  219.         return 1
  220.     }
  221.  
  222.     # Do we have valid info for 'deptype' ?
  223.     [ -z "$(eval echo \${rc_$1})" ] && return 1
  224.  
  225.     if [ "$2" = "-t" -a -n "$4" ]
  226.     then
  227.         # Check if 'service1' have 'deptype' dependency on 'service2'
  228.         for x in $(eval echo \${rc_$1})
  229.         do
  230.             [ "${x}" = "$4" ] && return 0
  231.         done
  232.     else
  233.         # Just list all services that 'service1' have 'deptype' dependency on.
  234.         eval echo "\${rc_$1}"
  235.  
  236.         return 0
  237.     fi
  238.  
  239.     return 1
  240. }
  241.  
  242. # Same as for check_dependency, except 'deptype' is set to
  243. # 'ineed'.  It will return all the services 'service1' NEED's.
  244. ineed() {
  245.     [ -z "$1" ] && return 1
  246.     
  247.     check_dependency ineed $*
  248.     
  249.     return $?
  250. }
  251.  
  252. # Same as for check_dependency, except 'deptype' is set to
  253. # 'needsme'.  It will return all the services that NEED 'service1'.
  254. needsme() {
  255.     [ -z "$1" ] && return 1
  256.     
  257.     check_dependency needsme $*
  258.  
  259.     return $?
  260. }
  261.  
  262. # Same as for check_dependency, except 'deptype' is set to
  263. # 'iuse'.  It will return all the services 'service1' USE's.
  264. iuse() {
  265.     [ -z "$1" ] && return 1
  266.     
  267.     check_dependency iuse $*
  268.  
  269.     return $?
  270. }
  271.  
  272. # Same as for check_dependency, except 'deptype' is set to
  273. # 'usesme'.  It will return all the services that USE 'service1'.
  274. usesme() {
  275.     [ -z "$1" ] && return 1
  276.     
  277.     check_dependency usesme $*
  278.  
  279.     return $?
  280. }
  281.  
  282. # Same as for check_dependency, except 'deptype' is set to
  283. # 'ibefore'.  It will return all the services that are started
  284. # *after* 'service1' (iow, it will start 'service1' before the
  285. # list of services returned).
  286. ibefore() {
  287.     [ -z "$1" ] && return 1
  288.     
  289.     check_dependency ibefore $*
  290.  
  291.     return $?
  292. }
  293.  
  294. # Same as for check_dependency, except 'deptype' is set to
  295. # 'iafter'.  It will return all the services that are started
  296. # *before* 'service1' (iow, it will start 'service1' after the
  297. # list of services returned).
  298. iafter() {
  299.     [ -z "$1" ] && return 1
  300.     
  301.     check_dependency iafter $*
  302.  
  303.     return $?
  304. }
  305.  
  306. # Same as for check_dependency, except 'deptype' is set to
  307. # 'broken'.  It will return all the services that 'service1'
  308. # NEED, but are not present.
  309. broken() {
  310.     [ -z "$1" ] && return 1
  311.  
  312.     check_dependency broken $*
  313.     
  314.     return $?
  315. }
  316.  
  317. # bool iparallel(service)
  318. #
  319. #   Returns true if the service can be started in parallel.
  320. #
  321. iparallel() {
  322.     [ -z "$1" ] && return 1
  323.  
  324.     if check_dependency parallel -t "$1" "no"
  325.     then
  326.         return 1
  327.     fi
  328.  
  329.     return 0
  330. }
  331.  
  332. # bool is_fake_service(service, runlevel)
  333. #
  334. #   Returns ture if 'service' is a fake service in 'runlevel'.
  335. #
  336. is_fake_service() {
  337.     local x=
  338.     local fake_services=
  339.  
  340.     [ -z "$1" -o -z "$2" ] && return 1
  341.  
  342.     if [ "$2" != "${BOOTLEVEL}" -a \
  343.          -e "/etc/runlevels/${BOOTLEVEL}/.fake" ]
  344.     then
  345.         fake_services="$(< /etc/runlevels/${BOOTLEVEL}/.fake)"
  346.     fi
  347.  
  348.     if [ -e "/etc/runlevels/$2/.fake" ]
  349.     then
  350.         fake_services="${fake_services} $(< /etc/runlevels/$2/.fake)"
  351.     fi
  352.  
  353.     for x in ${fake_services}
  354.     do
  355.         if [ "$1" = "${x##*/}" ]
  356.         then
  357.             return 0
  358.         fi
  359.     done
  360.  
  361.     return 1
  362. }
  363.  
  364. # bool in_runlevel(service, runlevel)
  365. #
  366. #   Returns true if 'service' is in runlevel 'runlevel'.
  367. #
  368. in_runlevel() {
  369.     [ -z "$1" -o -z "$2" ] && return 1
  370.  
  371.     [ -L "/etc/runlevels/$2/$1" ] && return 0
  372.  
  373.     return 1
  374. }
  375.  
  376. # bool is_runlevel_start()
  377. #
  378. #   Returns true if it is a runlevel change, and we are busy
  379. #   starting services.
  380. #
  381. is_runlevel_start() {
  382.     [ -d "${svcdir}/softscripts.old" ] && return 0
  383.  
  384.     return 1
  385. }
  386.  
  387. # bool is_runlevel_stop()
  388. #
  389. #   Returns true if it is a runlevel change, and we are busy
  390. #   stopping services.
  391. #
  392. is_runlevel_stop() {
  393.     [ -d "${svcdir}/softscripts.new" ] && return 0
  394.  
  395.     return 1
  396. }
  397.  
  398. # int start_service(service)
  399. #
  400. #   Start 'service' if it is not already running.
  401. #
  402. start_service() {
  403.     local retval=0
  404.     
  405.     [ -z "$1" ] && return 1
  406.     
  407.     if ! service_started "$1"
  408.     then
  409.         splash "svc_start" "$1"
  410.             
  411.         if is_fake_service "$1" "${SOFTLEVEL}"
  412.         then
  413.             mark_service_started "$1"
  414.             splash "svc_started" "$1" "0"
  415.         else
  416.             (. /sbin/runscript.sh "/etc/init.d/$1" start)
  417.             retval="$?"
  418.             splash "svc_started" "$1" "${retval}"
  419.             return "${retval}"
  420.         fi
  421.     fi
  422.  
  423.     return 0
  424. }
  425.  
  426. # int stop_service(service)
  427. #
  428. #   Stop 'service' if it is not already running.
  429. #
  430. stop_service() {
  431.     local retval=0
  432.     
  433.     [ -z "$1" ] && return 1
  434.  
  435.     if service_started "$1"
  436.     then
  437.         splash "svc_stop" "$1"
  438.             
  439.         if is_runlevel_stop
  440.         then
  441.             if is_fake_service "$1" "${OLDSOFTLEVEL}"
  442.             then
  443.                 mark_service_stopped "$1"
  444.                 splash "svc_stopped" "$1" "0"
  445.                 return 0
  446.             fi
  447.         else
  448.             if is_fake_service "$1" "${SOFTLEVEL}"
  449.             then
  450.                 mark_service_stopped "$1"
  451.                 splash "svc_stopped" "$1" "0"
  452.                 return 0
  453.             fi
  454.         fi
  455.  
  456.         (. /sbin/runscript.sh "/etc/init.d/$1" stop)
  457.         retval="$?"
  458.         splash "svc_stopped" "$1" "${retval}"
  459.         return "${retval}"
  460.     fi
  461.  
  462.     return 0
  463. }
  464.  
  465. # bool mark_service_started(service)
  466. #
  467. #   Mark 'service' as started.
  468. #
  469. mark_service_started() {
  470.     [ -z "$1" ] && return 1
  471.  
  472.     ln -snf "/etc/init.d/$1" "${svcdir}/started/$1"
  473.  
  474.     return $?
  475. }
  476.  
  477. # bool mark_service_stopped(service)
  478. #
  479. #   Mark 'service' as stopped.
  480. #
  481. mark_service_stopped() {
  482.     [ -z "$1" ] && return 1
  483.  
  484.     rm -f "${svcdir}/started/$1"
  485.  
  486.     return $?
  487. }
  488.  
  489. # bool service_started(service)
  490. #
  491. #   Returns true if 'service' is started
  492. #
  493. service_started() {
  494.     [ -z "$1" ] && return 1
  495.  
  496.     if [ -L "${svcdir}/started/$1" ]
  497.     then
  498.         if [ ! -e "${svcdir}/started/$1" ]
  499.         then
  500.             rm -f "${svcdir}/started/$1"
  501.             
  502.             return 1
  503.         fi
  504.         return 0
  505.     fi
  506.  
  507.     return 1
  508. }
  509.  
  510. # bool mark_service_failed(service)
  511. #
  512. #   Mark service as failed for current runlevel.  Note that
  513. #   this is only valid on runlevel change ...
  514. #
  515. mark_service_failed() {
  516.     [ -z "$1" ] && return 1
  517.  
  518.     if [ -d "${svcdir}/failed" ]
  519.     then
  520.         ln -snf "/etc/init.d/$1" "${svcdir}/failed/$1"
  521.         return $?
  522.     fi
  523.  
  524.     return 1
  525. }
  526.  
  527. # bool service_failed(service)
  528. #
  529. #   Return true if 'service' have failed during this runlevel.
  530. #
  531. service_failed() {
  532.     [ -z "$1" ] && return 1
  533.     
  534.     if [ -L "${svcdir}/failed/$1" ]
  535.     then
  536.         return 0
  537.     fi
  538.  
  539.     return 1
  540. }
  541.  
  542. # bool net_service(service)
  543. #
  544. #   Returns true if 'service' is a service controlling a network interface
  545. #
  546. net_service() {
  547.     [ -z "$1" ] && return 1
  548.  
  549.     if [ "${1%%.*}" = "net" -a "${1##*.}" != "$1" ]
  550.     then
  551.         return 0
  552.     fi
  553.  
  554.     return 1 
  555. }
  556.  
  557. # bool is_net_up()
  558. #
  559. #    Return true if service 'net' is considered up, else false.
  560. #
  561. #    Notes for RC_NET_STRICT_CHECKING values:
  562. #      none  net is up without checking anything - usefull for vservers
  563. #      lo    Interface 'lo' is counted and if only it is up, net is up.
  564. #      no    Interface 'lo' is not counted, and net is down even with it up,
  565. #            so there have to be at least one other interface up.
  566. #      yes   All interfaces must be up.
  567. is_net_up() {
  568.     local netcount=0
  569.  
  570.     case "${RC_NET_STRICT_CHECKING}" in
  571.         none)
  572.             return 0
  573.             ;;
  574.         lo)
  575.             netcount="$(ls -1 "${svcdir}"/started/net.* 2> /dev/null | \
  576.                         egrep -c "\/net\..*$")"
  577.             ;;
  578.         *)
  579.             netcount="$(ls -1 "${svcdir}"/started/net.* 2> /dev/null | \
  580.                         grep -v 'net\.lo' | egrep -c "\/net\..*$")"
  581.             ;;
  582.     esac
  583.  
  584.     # Only worry about net.* services if this is the last one running,
  585.     # or if RC_NET_STRICT_CHECKING is set ...
  586.     if [ "${netcount}" -lt 1 -o "${RC_NET_STRICT_CHECKING}" = "yes" ]
  587.     then
  588.         return 1
  589.     fi
  590.  
  591.     return 0
  592. }
  593.  
  594. # void schedule_service_startup(service)
  595. #
  596. #   Schedule 'service' for startup, in parallel if possible.
  597. #
  598. schedule_service_startup() {
  599.     local count=0
  600.     local current_job=
  601.  
  602.     if [ "${RC_PARALLEL_STARTUP}" = "yes" ]
  603.     then
  604.         set -m +b
  605.  
  606.         if [ "$(jobs | grep -c "Running")" -gt 0 ]
  607.         then
  608.             if [ "$(jobs | grep -c "Running")" -eq 1 ]
  609.             then
  610.                 if [ -n "$(jobs)" ]
  611.                 then
  612.                     current_job="$(jobs | awk '/Running/ { print $4}')"
  613.                 fi
  614.                 
  615.                 # Wait if we cannot start this service with the already running
  616.                 # one (running one might start this one ...).
  617.                 query_before "$1" "${current_job}" && wait
  618.  
  619.             elif [ "$(jobs | grep -c "Running")" -ge 2 ]
  620.             then
  621.                 count="$(jobs | grep -c "Running")"
  622.  
  623.                 # Wait until we have only one service running
  624.                 while [ "${count}" -gt 1 ]
  625.                 do
  626.                     count="$(jobs | grep -c "Running")"
  627.                 done
  628.  
  629.                 if [ -n "$(jobs)" ]
  630.                 then
  631.                     current_job="$(jobs | awk '/Running/ { print $4}')"
  632.                 fi
  633.  
  634.                 # Wait if we cannot start this service with the already running
  635.                 # one (running one might start this one ...).
  636.                 query_before "$1" "${current_job}" && wait
  637.             fi
  638.         fi
  639.  
  640.         if iparallel "$1"
  641.         then
  642.             eval start_service "$1" \&
  643.         else
  644.             # Do not start with any service running if we cannot start
  645.             # this service in parallel ...
  646. #            wait
  647.             
  648.             start_service "$1"
  649.         fi
  650.     else
  651.         start_service "$1"
  652.     fi
  653.  
  654.     # We do not need to check the return value here, as svc_{start,stop}() do
  655.     # their own error handling ...
  656.     return 0
  657. }
  658.  
  659. # bool dependon(service1, service2)
  660. #
  661. #   Does service1 depend (NEED or USE) on service2 ?
  662. #
  663. dependon() {
  664.     [ -z "$1" -o -z "$2" ] && return 1
  665.     
  666.     if ineed -t "$1" "$2" || iuse -t "$1" "$2"
  667.     then
  668.         return 0
  669.     fi
  670.  
  671.     return 1
  672. }
  673.  
  674. # string valid_iuse(service)
  675. #
  676. #   This will only give the valid use's for the service
  677. #   (they must be in the boot or current runlevel)
  678. #
  679. valid_iuse() {
  680.     local x=
  681.     local y=
  682.  
  683.     for x in $(iuse "$1")
  684.     do
  685.         if [ -e "/etc/runlevels/${BOOTLEVEL}/${x}" -o \
  686.              -e "/etc/runlevels/${mylevel}/${x}" -o \
  687.              ${x} = "net" ]
  688.         then
  689.             echo "${x}"
  690.         fi
  691.     done
  692.  
  693.     return 0
  694. }
  695.  
  696. # string valid_iafter(service)
  697. #
  698. #   Valid services for current or boot rc level that should start
  699. #   before 'service'
  700. #
  701. valid_iafter() {
  702.     local x=
  703.     
  704.     for x in $(iafter "$1")
  705.     do
  706.         if [ -e "/etc/runlevels/${BOOTLEVEL}/${x}" -o \
  707.              -e "/etc/runlevels/${mylevel}/${x}" -o \
  708.              ${x} = "net" ]
  709.         then
  710.             echo "${x}"
  711.         fi
  712.     done
  713.  
  714.     return 0
  715. }
  716.  
  717. # void trace_depend(deptype, service, deplist)
  718. #
  719. #   Trace the dependency tree of 'service' for type 'deptype', and
  720. #   modify 'deplist' with the info.
  721. #
  722. trace_depend() {
  723.     local x=
  724.     local y=
  725.     local add=
  726.  
  727.     [ -z "$1" -o -z "$2" -o -z "$3" ] && return 1
  728.  
  729.     # Build the list of services that 'deptype' on this one
  730.     for x in "$("$1" "$2")"
  731.     do
  732.         add="yes"
  733.         
  734.         for y in $(eval echo "\${$3}")
  735.         do
  736.             [ "${x}" = "${y}" ] && add="no"
  737.         done
  738.  
  739.         [ "${add}" = "yes" ] && eval $(echo "$3=\"\${$3} ${x}\"")
  740.         
  741.         # Recurse to build a complete list ...
  742.         trace_depend "$1" "${x}" "$3"
  743.     done
  744.  
  745.     return 0
  746. }
  747.  
  748. # string list_depend_trace(deptype)
  749. #
  750. #   Return resulting list of services for a trace of
  751. #   type 'deptype' for $myservice
  752. #
  753. list_depend_trace() {
  754.     local x=
  755.     local list=
  756.  
  757.     [ -z "$1" ] && return 1
  758.     
  759.     trace_depend "$1" "${myservice}" "list"
  760.  
  761.     for x in ${list}
  762.     do
  763.         echo "${x}"
  764.     done
  765.  
  766.     return 0
  767. }
  768.  
  769. # bool query_before(service1, service2)
  770. #
  771. #   Return true if 'service2' should be started *before*
  772. #   service1.
  773. #
  774. query_before() {
  775.     local x=
  776.     local list=
  777.     local netservice="no"
  778.  
  779.     [ -z "$1" -o -z "$2" ] && return 1
  780.  
  781.     trace_depend "ineed" "$1" "list"
  782.  
  783.     for x in $1 ${list}
  784.     do
  785.         trace_depend "iuse" "${x}" "list"
  786.     done
  787.  
  788.     for x in $1 ${list}
  789.     do
  790.         trace_depend "iafter" "${x}" "list"
  791.     done
  792.  
  793.     net_service "$2" && netservice="yes"
  794.     
  795.     for x in ${list}
  796.     do
  797.         [ "${x}" = "$2" ] && return 0
  798.  
  799.         # Also match "net" if this is a network service ...
  800.         [ "${netservice}" = "yes" -a "${x}" = "net" ] && return 0
  801.     done
  802.  
  803.     return 1
  804. }
  805.  
  806. # bool query_after(service1, service2)
  807. #
  808. #   Return true if 'service2' should be started *after*
  809. #   service1.
  810. #
  811. query_after() {
  812.     local x=
  813.     local list=
  814.     local netservice="no"
  815.  
  816.     [ -z "$1" -o -z "$2" ] && return 1
  817.  
  818.     trace_depend "needsme" "$1" "list"
  819.  
  820.     for x in $1 ${list}
  821.     do
  822.         trace_depend "usesme" "${x}" "list"
  823.     done
  824.  
  825.     for x in $1 ${list}
  826.     do
  827.         trace_depend "ibefore" "${x}" "list"
  828.     done
  829.  
  830.     net_service "$2" && netservice="yes"
  831.  
  832.     for x in ${list}
  833.     do
  834.         [ "${x}" = "$2" ] && return 0
  835.  
  836.         # Also match "net" if this is a network service ...
  837.         [ "${netservice}" = "yes" -a "${x}" = "net" ] && return 0
  838.     done
  839.  
  840.     return 1
  841. }
  842.  
  843.  
  844. # vim:ts=4
  845.